package solutions.ferpa.ztest.intf;

import br.com.telescope.adsrt.dom.DomEMail;
import br.com.telescope.adsrt.dom.DomFlag;
import br.com.telescope.adsrt.dom.DomInteger;
import br.com.telescope.adsrt.dom.DomOpcao;
import br.com.telescope.adsrt.dom.DomSourceCode;
import br.com.telescope.adsrt.dom.DomText;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.ServiceModel;
import br.com.telescope.t2.exception.ApplicationRuntimeException;
import br.com.telescope.t2.feature.CustomFeature;
import br.com.telescope.t2.feature.MethodFeature;
import solutions.ferpa.ztest.ent.*;

/**
 * Configuração de e-mail.
 * <p>
 * Interface que permite configurar e testar o envio de e-mail a partir 
 * da aplicação. Define os parâmetros a serem utilizados, tais como 
 * endereço do servidor de SMTP, nome de usuário de autenticação, etc.
 * <P>
 * 
 * <P>
 * O e-mail de teste é inicialmente populado com o e-mail do usuário da 
 * sessão corrente. O usuário pode alterar este e-mail temporariamente 
 * para executar o teste, mas essa informação não é salva no sistema (a 
 * próxima vez que entrar volta o e-mail do usuário).
 * <P>
 * 
 * <P>
 * Telescope origin: RTPREF.CFG_MAIL
 * <P>
 * @author TELESCOPE - Build task T2 Web Interface Generator
 * <P>
 * @version 0.1
 */
public class CfgMail extends ServiceModel {
    
    // <editor-fold defaultstate="collapsed" desc="Generated Code">
    public static final String GLOBAL_NAME = "RTPREF.CFG_MAIL";
    
    @Override
    public String globalName() {
        return GLOBAL_NAME;
    }
    
    {
        setTitle("Configuração de e-mail");
    }
    
    
    // Record items
    private DomText aSmtpHost;
    private DomInteger aSmtpPort;
    private DomText aSmtpUser;
    private DomText aSmtpPassword;
    private DomFlag aSmtpSsl;
    private DomFlag aSmtpTls;
    private DomText aSmtpLocalhost;
    private DomText aSmtpDefaultFrom;
    private DomEMail aSmtpReplayTo;
    private DomFlag aConfirmacaoLeitura;
    private DomOpcao aReportErrorsSeverity;
    private DomText aReportErrorsToEmail;
    private DomText aReportErrorsFromEmail;
    private DomSourceCode aReportMessageTemplate;
    private DomText aEMailTeste;
    
    // Query items
    
    @Override
    public void initAttributes() {
        
        aSmtpHost = new DomText();
        aSmtpHost.context(ctx).name("SMTP_HOST").label("Servidor SMTP").unbound(true);
        
        aSmtpPort = new DomInteger();
        aSmtpPort.context(ctx).name("SMTP_PORT").label("Porta").unbound(true);
        
        aSmtpUser = new DomText();
        aSmtpUser.context(ctx).name("SMTP_USER").label("Usuário de autenticação do SMTP").unbound(true);
        
        aSmtpPassword = new DomText();
        aSmtpPassword.context(ctx).name("SMTP_PASSWORD").label("Senha de autenticação no SMTP").unbound(true);
        
        aSmtpSsl = new DomFlag();
        aSmtpSsl.context(ctx).name("SMTP_SSL").label("Usa SSL").unbound(true);
        
        aSmtpTls = new DomFlag();
        aSmtpTls.context(ctx).name("SMTP_TLS").label("Usa TLS").unbound(true);
        
        aSmtpLocalhost = new DomText();
        aSmtpLocalhost.context(ctx).name("SMTP_LOCALHOST").label("Localhost").unbound(true);
        
        aSmtpDefaultFrom = new DomText();
        aSmtpDefaultFrom.context(ctx).name("SMTP_DEFAULT_FROM").label("Remetente padrão").unbound(true);
        
        aSmtpReplayTo = new DomEMail();
        aSmtpReplayTo.context(ctx).name("SMTP_REPLAY_TO").label("E-mail para resposta").unbound(true);
        
        aConfirmacaoLeitura = new DomFlag();
        aConfirmacaoLeitura.context(ctx).name("CONFIRMACAO_LEITURA").label("Confirmação de leitura").unbound(true);
        
        aReportErrorsSeverity = new DomOpcao();
        aReportErrorsSeverity.context(ctx).name("REPORT_ERRORS_SEVERITY").label("Nível de severidade das mensagens do sistema").unbound(true).group(true);
        aReportErrorsSeverity.addOption("1", "Warning");
        aReportErrorsSeverity.addOption("2", "Error");
        aReportErrorsSeverity.addOption("3", "Unknown");
        aReportErrorsSeverity.addOption("4", "Critical");
        aReportErrorsSeverity.addOption("5", "Panic");
        
        aReportErrorsToEmail = new DomText();
        aReportErrorsToEmail.context(ctx).name("REPORT_ERRORS_TO_EMAIL").label("E-mail destinatário para mensagens do sistema").unbound(true);
        
        aReportErrorsFromEmail = new DomText();
        aReportErrorsFromEmail.context(ctx).name("REPORT_ERRORS_FROM_EMAIL").label("E-mail remetente para mensagens do sistema").unbound(true);
        
        aReportMessageTemplate = new DomSourceCode();
        aReportMessageTemplate.context(ctx).name("REPORT_MESSAGE_TEMPLATE").label("Mensagem de erro").height(10).unbound(true);
        
        aEMailTeste = new DomText();
        aEMailTeste.context(ctx).name("E_MAIL_TESTE").label("E-mail para teste").unbound(true);
        
    }
    
    @Override
    public String getDefaultOrderBy() {
        return "";
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="CUSTOM">
    public class FCustom extends CustomFeature {
        
        @Override
        public void initForm() {
            aSmtpHost.setOptional(false);
            addField(aSmtpHost, "rqd");
            addField(aSmtpPort, "opt");
            addField(aSmtpUser, "opt");
            addField(aSmtpPassword, "opt");
            addField(aSmtpSsl, "opt");
            addField(aSmtpTls, "opt");
            addField(aSmtpLocalhost, "opt");
            addField(aSmtpDefaultFrom, "opt");
            addField(aSmtpReplayTo, "opt");
            addField(aConfirmacaoLeitura, "opt");
            addField(aReportErrorsSeverity, "opt");
            addField(aReportErrorsToEmail, "opt");
            addField(aReportErrorsFromEmail, "opt");
            addField(aReportMessageTemplate, "opt");
            addField(aEMailTeste, "opt");
        }
        
        @Override
        public void preDisplay() {
            try {
                lerConfiguracoes();
            } catch (AdsException ex) {
                throw new ApplicationRuntimeException(ex);
            }
        }
        
        @Override
        public void onAction() {
            addSubmit(getFeature("TESTAR_CONFIGURACOES")).label("Testar configurações").shortCutKey("F8").icon("message.gif");
            addSubmit(getFeature("SALVAR_CONFIGURACOES")).label("Salvar configurações").shortCutKey("F3").icon("salvar.gif");
        }
        
        {
            setFeatureName("CUSTOM");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="TESTAR_CONFIGURACOES">
    public class FTestarConfiguracoes extends MethodFeature {
        
        @Override
        public void run() {
            preRun();
            try {
                testarConfiguracoes();
            } catch (AdsException ex) {
                throw new ApplicationRuntimeException(ex);
            }
        }
        
        {
            setFeatureName("TESTAR_CONFIGURACOES");
            setTitle("Testar configurações");
            setShortCutKey("F8");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="SALVAR_CONFIGURACOES">
    public class FSalvarConfiguracoes extends MethodFeature {
        
        @Override
        public void run() {
            preRun();
            try {
                salvarConfiguracoes();
            } catch (AdsException ex) {
                throw new ApplicationRuntimeException(ex);
            }
        }
        
        {
            setFeatureName("SALVAR_CONFIGURACOES");
            setTitle("Salvar configurações");
            setShortCutKey("F3");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="initFeatures">
    
    @Override
    protected void initFeatures() {
        addFeature(new FCustom());
        addFeature(new FTestarConfiguracoes());
        addFeature(new FSalvarConfiguracoes());
        super.initFeatures();
    }
    
    @Override
    public String getDefaultFeature() {
        return "CUSTOM";
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Getters and Setters">
    
    public String getSmtpHost() {
        return aSmtpHost.getValue();
    }
    
    public void setSmtpHost(String value) {
        this.aSmtpHost.setValue(value);
    }
    
    public Integer getSmtpPort() {
        return aSmtpPort.getValue();
    }
    
    public void setSmtpPort(Integer value) {
        this.aSmtpPort.setValue(value);
    }
    
    public String getSmtpUser() {
        return aSmtpUser.getValue();
    }
    
    public void setSmtpUser(String value) {
        this.aSmtpUser.setValue(value);
    }
    
    public String getSmtpPassword() {
        return aSmtpPassword.getValue();
    }
    
    public void setSmtpPassword(String value) {
        this.aSmtpPassword.setValue(value);
    }
    
    public String getSmtpSsl() {
        return aSmtpSsl.getValue();
    }
    
    public void setSmtpSsl(String value) {
        this.aSmtpSsl.setValue(value);
    }
    
    public String getSmtpTls() {
        return aSmtpTls.getValue();
    }
    
    public void setSmtpTls(String value) {
        this.aSmtpTls.setValue(value);
    }
    
    public String getSmtpLocalhost() {
        return aSmtpLocalhost.getValue();
    }
    
    public void setSmtpLocalhost(String value) {
        this.aSmtpLocalhost.setValue(value);
    }
    
    public String getSmtpDefaultFrom() {
        return aSmtpDefaultFrom.getValue();
    }
    
    public void setSmtpDefaultFrom(String value) {
        this.aSmtpDefaultFrom.setValue(value);
    }
    
    public String getSmtpReplayTo() {
        return aSmtpReplayTo.getValue();
    }
    
    public void setSmtpReplayTo(String value) {
        this.aSmtpReplayTo.setValue(value);
    }
    
    public String getConfirmacaoLeitura() {
        return aConfirmacaoLeitura.getValue();
    }
    
    public void setConfirmacaoLeitura(String value) {
        this.aConfirmacaoLeitura.setValue(value);
    }
    
    public String getReportErrorsSeverity() {
        return aReportErrorsSeverity.getValue();
    }
    
    public void setReportErrorsSeverity(String value) {
        this.aReportErrorsSeverity.setValue(value);
    }
    
    public String getReportErrorsToEmail() {
        return aReportErrorsToEmail.getValue();
    }
    
    public void setReportErrorsToEmail(String value) {
        this.aReportErrorsToEmail.setValue(value);
    }
    
    public String getReportErrorsFromEmail() {
        return aReportErrorsFromEmail.getValue();
    }
    
    public void setReportErrorsFromEmail(String value) {
        this.aReportErrorsFromEmail.setValue(value);
    }
    
    public String getReportMessageTemplate() {
        return aReportMessageTemplate.getValue();
    }
    
    public void setReportMessageTemplate(String value) {
        this.aReportMessageTemplate.setValue(value);
    }
    
    public String getEMailTeste() {
        return aEMailTeste.getValue();
    }
    
    public void setEMailTeste(String value) {
        this.aEMailTeste.setValue(value);
    }
    // </editor-fold>
    
    /**
     * Ler as configurações.
     * <p>
     * Lê as preferencias preparando o formulário para consulta e/ou 
     * alteração.
     * <P>
     */
    private void lerConfiguracoes() throws AdsException {
        // <user-code id="806829" parentId="795466" hashcode="8ecb57b" length="1477">
        aSmtpHost.setValue(ctx.getPreference("SMTP_HOST"));
        aSmtpLocalhost.setValue(ctx.getPreference("SMTP_LOCALHOST"));
        aSmtpPassword.setValue(ctx.getPreference("SMTP_PASSWORD"));
        aSmtpPort.setValue(ctx.getPreference("SMTP_PORT","25"));
        aSmtpUser.setValue(ctx.getPreference("SMTP_USER"));
        aSmtpTls.setValue(ctx.getPreference("SMTP_TLS"));
        aSmtpSsl.setValue(ctx.getPreference("SMTP_SSL"));
        aConfirmacaoLeitura.setValue(ctx.getPreference("SMTP_CONFIRMACAO_LEITURA"));
        aSmtpReplayTo.setValue(ctx.getPreference("SMTP_REPLAY_TO"));
        
        aSmtpDefaultFrom.setValue(ctx.getPreference("SMTP_DEFAULT_FROM"));
        aReportErrorsSeverity.setValue(ctx.getPreference("RT.REPORT_ERRORS_SEVERITY"));
        aReportErrorsFromEmail.setValue(ctx.getPreference("RT.REPORT_ERRORS_FROM_EMAIL"));
        aReportErrorsToEmail.setValue(ctx.getPreference("RT.REPORT_ERRORS_TO_EMAIL"));
        aReportMessageTemplate.setValue(ctx.getPreference("RT.REPORT_ERRORS_MESSAGE_TEMPLATE",
                                "\n" +
                                "*Usuário*: ${userName}\n" +
                                "*Erros*: ${errorsReport}\n" +
                                "\n" +
                                "*Parâmetros:* ${parameters}\n" +
                                "\n" +
                                "*Log da sessão:* ${sessionLog}\n"
        ));
        
        aEMailTeste.setValue(ctx.getParameter("A_E_MAIL_TESTE"));
        if (aEMailTeste.isNull()) {
            EntUsuarios user = new EntUsuarios(ctx);
            user.find(ctx.getUserId());
            aEMailTeste.setValue(user.getEMail());
        }
        // </user-code>
    }
    
    /**
     * Salvar configurações.
     * <p>
     * Método que salva as configurações informadas.
     * <P>
     */
    private void salvarConfiguracoes() throws AdsException {
        // <user-code id="800549" parentId="795462" hashcode="25c2ec30" length="1203">
        ctx.setPreference("SMTP_HOST", ctx.getParameter("A_SMTP_HOST"));
        ctx.setPreference("SMTP_LOCALHOST", ctx.getParameter("A_SMTP_LOCALHOST"));
        ctx.setPreference("SMTP_PASSWORD", ctx.getParameter("A_SMTP_PASSWORD"));
        ctx.setPreference("SMTP_PORT", ctx.getParameter("A_SMTP_PORT"));
        ctx.setPreference("SMTP_USER", ctx.getParameter("A_SMTP_USER"));
        ctx.setPreference("SMTP_TLS", ctx.getParameter("A_SMTP_TLS"));
        ctx.setPreference("SMTP_SSL", ctx.getParameter("A_SMTP_SSL"));
        ctx.setPreference("SMTP_CONFIRMACAO_LEITURA", ctx.getParameter("A_CONFIRMACAO_LEITURA"));
        ctx.setPreference("SMTP_REPLAY_TO", ctx.getParameter("A_SMTP_REPLAY_TO"));
        
        ctx.setPreference("SMTP_DEFAULT_FROM", ctx.getParameter("A_SMTP_DEFAULT_FROM"));
        ctx.setPreference("RT.REPORT_ERRORS_SEVERITY", ctx.getParameter("A_REPORT_ERRORS_SEVERITY"));
        ctx.setPreference("RT.REPORT_ERRORS_FROM_EMAIL", ctx.getParameter("A_REPORT_ERRORS_FROM_EMAIL"));
        ctx.setPreference("RT.REPORT_ERRORS_TO_EMAIL", ctx.getParameter("A_REPORT_ERRORS_TO_EMAIL"));
        ctx.setPreference("RT.REPORT_ERRORS_MESSAGE_TEMPLATE", ctx.getParameter("A_REPORT_MESSAGE_TEMPLATE"));
        
        ctx.showSuccess("Configurações salvas com sucesso");
        getFeatures().get(0).run();
        // </user-code>
    }
    
    /**
     * Testar configurações.
     * <p>
     * Executa o teste de envio de um e-mail para o endereço informado, 
     * reportando qualquer erro encontrado.
     * <P>
     */
    private void testarConfiguracoes() throws AdsException {
        // <user-code id="800547" parentId="795468" hashcode="780efaef" length="588">
        salvarConfiguracoes();
        EntUsuarios user = new EntUsuarios(ctx);
        user.find(ctx.getUserId());
        
        String to;
        if (aEMailTeste.isNull()) {
            to = user.valueOfEMail();
        } else {
            to = aEMailTeste.getValue();
        }
        StringBuilder temp = new StringBuilder(255);
        temp.append("Teste: ");
        for (int i=32;i<255;i++) {
            temp.append((char)i);
        }
        temp.append("<br>LOCALE: ").append(ctx.getLocale().toString());
        temp.append("<br>");
        ctx.sendHtmlMail(to, null, "Teste de e-mail", "Mensagem de teste <br>" + temp.toString() );
        ctx.showSuccess("Enviado e-mail para " + to + " com sucesso!");
        // </user-code>
    }
}
